package Test;

import java.util.Arrays;

public class Arraylist<E> {

    public E[] elem;//创建这个成员变量
    public int usedSize;//0/。记录长度
    //默认容量
    private static final int DEFAULT_SIZE = 10;

    public Arraylist() {//初始化数组
        this.elem = (E[]) new Object[DEFAULT_SIZE];
    }

    public Arraylist(int p) {
        this.elem = (E[]) new Object[p];
    }

    /**
     * 打印顺序表:
     * 根据usedSize判断即可
     */
//    public void display() {
//        List<Integer> list = new ArrayList<>();
//        Iterator<Integer> it = list.listIterator();
//        while(it.hasNext()){
//            System.out.print(it.next() + " ");
//        }
//        System.out.println();
//    }

    public void display4() {
        //依旧是打印全部数组
        for (E x:elem) {
            System.out.print(x+" ");
        }
        System.out.println();

    }


    public void display3() {
        //和上面情况一样！
        System.out.println(Arrays.asList(elem));
    }


    public void display() {
        for (int i = 0; i < usedSize; i++) {
            System.out.print(elem[i]+" ");
        }
        System.out.println();
    }
    public void display1() {
       //顺序表中不推荐使用
        System.out.println(Arrays.toString(elem));
    }
    //检查要输入的位置是否合法
    private boolean checkPosInAdd(int pos) throws SubscriptException {
        try {
            transboundary(pos);
        }catch (SubscriptException e) {
            System.out.println("捕捉到了下标异常");
            e.printStackTrace();
            return false;
        }
        return true;//合法
    }
    // 新增元素,默认在数组最后新增
    public void add(E data) {
        if (isFull()) {
           elem= Capacity(elem);
        }
        elem[usedSize]=data;
        usedSize++;
    }

    /**
     * 判断当前的顺序表是不是满的！
     *
     * @return true:满   false代表空
     */
    public boolean isFull() {
        return usedSize==elem.length;
    }
    public void transboundary(int pos) throws SubscriptException {
        if (pos>=usedSize) {
            throw new  SubscriptException("输入下标异常");
        }
    }
    //扩容数组
    public E[] Capacity(E[]array) {

        return Arrays.copyOf(array,array.length*2);
    }

    // 在 pos 位置新增元素
    public void add(int pos, E data) throws SubscriptException {

        //判断要插入的元素是否是最后一个位置
        if (pos==usedSize) {//如果是则调用尾插的方法
            add(data);
            return;
        }
        //判断输入的下标是否越界，
        //如果越界则直接返回
       if (!checkPosInAdd(pos)) {
           return;
       }
        //检查容量
        if (isFull()) {
            elem=Capacity(elem);
        }
        for (int i = usedSize-1; i >=pos; i--) {
            //向后覆盖
            elem[i+1]=elem[i];
        }
        set(pos,data);
        usedSize++;
        System.out.println("添加成功");
    }

    // 判定是否包含某个元素
    public boolean contains(E toFind) {
        for (int i = 0; i <usedSize ; i++) {
            if (elem[i].equals(toFind)) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(E toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (elem[i].equals(toFind)) {
                return i;
            }
        }
        return -1;
    }

    // 获取 pos 位置的元素
    public E get(int pos) throws SubscriptException {

        if (checkPosInAdd(pos)) {
            return null;//没有找到该元素
        }
        return elem[pos];
    }

    private boolean isEmpty() {
        //判断是否为空
        return elem==null;
    }

    // 给 pos 位置的元素设为【更新为】 value
    public void set(int pos, E value) throws SubscriptException {
        //修改元素
       if (!checkPosInAdd(pos)) {
           return;
       }
           elem[pos]=value;
    }

    /**
     * 删除第一次出现的关键字key
     *
     * @param key
     */
    public void remove(E key) {
        //后往前覆盖
        if (indexOf(key)!=-1) {
            int i=indexOf(key);
            if (elem[i]==key) {
                for (int j = i; j < usedSize-1; j++) {
                    elem[j]=elem[j+1];
                }
                elem[usedSize]=null;
                usedSize--;
            }
        }else {
            System.out.println("没有找到该元素");
        }
    }
    public void delete() {
        //删除最后一个元素
        elem[usedSize-1]=null;
        usedSize--;
    }
    public void delete(int pos) throws SubscriptException {
        //判断是否越界
        if (!checkPosInAdd(pos)) {
            return;
        }
        for (int i = pos; i < usedSize-1; i++) {
            elem[i]=elem[i+1];
        }
        elem[usedSize-1]=null;
        usedSize--;

    }

    // 获取顺序表长度
    public int size() {
        return usedSize;
    }

    // 清空顺序表
    public void clear() {
        usedSize=0;
    }

    public static void main(String[] args) throws SubscriptException {
        Arraylist <Integer>arraylist=new Arraylist<>();
        arraylist.add(1);
        arraylist.add(2);
        arraylist.add(3);
        arraylist.add(4);
        arraylist.delete(2);
        arraylist.display();
//        System.out.println("========");
//        arraylist.add(2,99);
//        arraylist.add(10,99);
//        arraylist.display();
//        System.out.println("=========");
//        arraylist.remove(99);
//        arraylist.display();
//        System.out.println("=========");
//        arraylist.set(0,1000);
//        arraylist.display();
      //  List<Integer> list = new ArrayList<>();
//        list.add(1);
//        list.add(2);
//        list.add(666);
//        list.add(888);
//        Iterator<Integer> it = list.listIterator();
//        while(it.hasNext()){
//            System.out.print(it.next() + " ");
//        }
//        System.out.println();
    }
}
class SubscriptException extends Exception {
    public SubscriptException(String e) {
        super(e);
    }

}